package com.llu.serial.fastjson;

import com.llu.serial.fastjson.deserializer.JavabeanDeserializer;
import com.llu.serial.fastjson.deserializer.ListDeserializer;
import com.llu.serial.fastjson.deserializer.ObjectDeserializer;
import com.llu.serial.fastjson.serializer.JavaBeanSerializer;
import com.llu.serial.fastjson.serializer.ListSerializer;
import com.llu.serial.fastjson.serializer.ObjectSerializer;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * JSON配置类，提供序列化和反序列化的配置信息。
 * 该类是单例模式的，通过getGlobInstance方法获取全局唯一的实例。
 */
public class JsonConfig {

    // 全局实例，确保JsonConfig的单例模式
    private static JsonConfig globInstance = new JsonConfig();

    // 序列化缓存
    private Map<Class,ObjectSerializer> serializers = new HashMap<>();
    private Map<Type,ObjectDeserializer> deserializers = new HashMap<>();

    /**
     * 获取全局唯一的JsonConfig实例。
     *
     * @return JsonConfig的全局实例。
     */
    public static JsonConfig getGlobInstance(){
        return globInstance;
    }

    /**
     * 获取指定类的序列化器。
     * 如果缓存中不存在该类的序列化器，则根据类的类型创建并缓存新的序列化器。
     *
     * @param clazz 需要序列化的类。
     * @return 该类的序列化器。
     */
    public ObjectSerializer getSerializer(Class<?> clazz){
        // 从缓存中获取指定类的序列化器
        ObjectSerializer objectSerializer = serializers.get(clazz);

        // 如果缓存中已存在该序列化器，则直接返回
        if(null != objectSerializer){
            return objectSerializer;
        }

        // 判断类的类型，并创建相应的序列化器
        if(List.class.isAssignableFrom(clazz)){
            // 如果是List类型，则使用ListSerializer
            objectSerializer = ListSerializer.instance;
        }else if(Map.class.isAssignableFrom(clazz)){
            // 如果是Map类型，目前不支持序列化，抛出异常
            throw new RuntimeException("Map序列化未实现");
        }else if(clazz.isArray()){
            // 如果是数组类型，目前不支持序列化，抛出异常
            throw new RuntimeException("数组序列化未实现");
        }else{
            // 对于其他普通JavaBean类型，创建对应的JavaBeanSerializer
            objectSerializer = new JavaBeanSerializer(clazz);
        }

        // 将新创建的序列化器缓存起来，供后续使用
        serializers.put(clazz,objectSerializer);
        return objectSerializer;
    }


    /**
     * 获取指定类型的反序列化器。
     * 如果缓存中不存在该类型的反序列化器，则根据类型的类型创建并缓存新的反序列化器。
     *
     * @param type 需要反序列化的类型。
     * @return 该类型的反序列化器。
     */
    public ObjectDeserializer getDeserializer(Type type){
        ObjectDeserializer objectDeserializer = deserializers.get(type);

        if(objectDeserializer != null){
            return objectDeserializer;
        }

        if(type instanceof Class){
            objectDeserializer = new JavabeanDeserializer((Class<?>) type);
        }else if(type instanceof ParameterizedType){
            // List<Items> 带参数类型
            objectDeserializer = new ListDeserializer((ParameterizedType) type);
        }
        deserializers.put(type,objectDeserializer);
        return objectDeserializer;
    }

}

